// This small demo sends a simple sinusoidal wave to your speakers.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sched.h>
#include <errno.h>
#include <getopt.h>
#include <sys/time.h>
#include <math.h>
#include "asoundlib.h"
#include "local.h"

static char *device = (char *)"plughw:0,0"; // Playback device
static snd_pcm_format_t format = SND_PCM_FORMAT_S16; // Sample format
static unsigned int rate = 44100; // Stream rate
static unsigned int channels = 1; // Count of channels
static unsigned int buffer_time = 500000; // Ring buffer length in us
static unsigned int period_time = 100000; // Period time in us
static double freq = 440; // Sinusoidal wave frequency in Hz
static int verbose = 0; // Verbose flag
static int resample = 1; // Enable alsa-lib resampling
static int period_event = 0; // Produce poll event after each period
static snd_pcm_sframes_t buffer_size;
static snd_pcm_sframes_t period_size;
static snd_output_t *output = NULL;

static void generate_sine(const snd_pcm_channel_area_t *areas,
						  snd_pcm_uframes_t offset,
						  int count,
						  double *_phase)
{
	static double max_phase = 2. * M_PI;
	double phase = *_phase;
	double step = max_phase * freq / (double) rate;
	unsigned char *samples[channels];
	int steps[channels];
	unsigned int chn;
	int format_bits = snd_pcm_format_width(format);
	unsigned int maxval = (1 << (format_bits - 1)) - 1;
	int bps = format_bits / 8; // Bytes per sample
	int phys_bps = snd_pcm_format_physical_width(format) / 8;
	int big_endian = snd_pcm_format_big_endian(format) == 1;
	int to_unsigned = snd_pcm_format_unsigned(format) == 1;
	int is_float = (format == SND_PCM_FORMAT_FLOAT_LE ||
			   	    format == SND_PCM_FORMAT_FLOAT_BE);

	// verify and prepare the contents of areas
	for (chn = 0; chn < channels; chn++)
	{
		if ((areas[chn].first % 8) != 0)
		{
			printf("areas[%i].first == %i, aborting...\n", chn,
					areas[chn].first);
			exit(EXIT_FAILURE);
		}

		samples[chn] = (((unsigned char *) areas[chn].addr)
				+ (areas[chn].first / 8));

		if ((areas[chn].step % 16) != 0)
		{
			printf("areas[%i].step == %i, aborting...\n", chn, areas[chn].step);
			exit(EXIT_FAILURE);
		}

		steps[chn] = areas[chn].step / 8;
		samples[chn] += offset * steps[chn];
	}

	// Fill the channel areas
	while (count-- > 0)
	{
		int res, i;
		union
		{
			float f;
			int i;
		}
		fval;

		if (is_float)
		{
			fval.f = sin(phase) * maxval;
			res = fval.i;
		}
		else
			res = sin(phase) * maxval;

		if (to_unsigned)
			res ^= 1U << (format_bits - 1);

		for (chn = 0; chn < channels; chn++)
		{
			// Generate data in native endian format
			if (big_endian)
			{
				for (i = 0; i < bps; i++)
				{
					*(samples[chn] + phys_bps - 1 - i) = (res >> i * 8) & 0xff;
				}
			}
			else
			{
				for (i = 0; i < bps; i++)
				{
					*(samples[chn] + i) = (res >> i * 8) & 0xff;
				}
			}
			samples[chn] += steps[chn];
		}
		phase += step;
		if (phase >= max_phase)
			phase -= max_phase;
	}
	*_phase = phase;
}

static int set_hwparams(snd_pcm_t *handle,
						snd_pcm_hw_params_t *params,
						snd_pcm_access_t access)
{
	unsigned int rrate;
	snd_pcm_uframes_t size;
	int err, dir;

	// Choose all parameters
	err = snd_pcm_hw_params_any(handle, params);
	if (err < 0)
	{
		printf("Broken configuration for playback: no configurations available: %s\n",
				snd_strerror(err));
		return (err);
	}

	// Set hardware resampling
	err = snd_pcm_hw_params_set_rate_resample(handle, params, resample);
	if (err < 0)
	{
		printf("Resampling setup failed for playback: %s\n", snd_strerror(err));
		return (err);
	}

	// Set the interleaved read/write format
	err = snd_pcm_hw_params_set_access(handle, params, access);
	if (err < 0)
	{
		printf("Access type not available for playback: %s\n",
				snd_strerror(err));
		return (err);
	}

	// Set the sample format
	err = snd_pcm_hw_params_set_format(handle, params, format);
	if (err < 0)
	{
		printf("Sample format not available for playback: %s\n",
				snd_strerror(err));
		return (err);
	}

	// Set the count of channels
	err = snd_pcm_hw_params_set_channels(handle, params, channels);
	if (err < 0)
	{
		printf("Channels count (%i) not available for playbacks: %s\n",
				channels, snd_strerror(err));
		return (err);
	}

	// Set the stream rate
	rrate = rate;
	err = snd_pcm_hw_params_set_rate_near(handle, params, &rrate, 0);
	if (err < 0)
	{
		printf("Rate %iHz not available for playback: %s\n", rate,
				snd_strerror(err));
		return (err);
	}

	// Check if rate read back matches requested rate
	if (rrate != rate)
	{
		printf("Rate doesn't match (requested %iHz, get %iHz)\n", rate, err);
		return (-EINVAL);
	}

	// Set the buffer time
	err = snd_pcm_hw_params_set_buffer_time_near(handle, params,
												 &buffer_time, &dir);
	if (err < 0)
	{
		printf("Unable to set buffer time %i for playback: %s\n", buffer_time,
				snd_strerror(err));
		return (err);
	}

	// Get the buffer size
	err = snd_pcm_hw_params_get_buffer_size(params, &size);
	if (err < 0)
	{
		printf("Unable to get buffer size for playback: %s\n",
				snd_strerror(err));
		return (err);
	}
	buffer_size = size;

	// Set the period time
	err = snd_pcm_hw_params_set_period_time_near(handle, params,
												 &period_time, &dir);
	if (err < 0)
	{
		printf("Unable to set period time %i for playback: %s\n", period_time,
				snd_strerror(err));
		return (err);
	}

	// Get the period size
	err = snd_pcm_hw_params_get_period_size(params, &size, &dir);
	if (err < 0)
	{
		printf("Unable to get period size for playback: %s\n",
				snd_strerror(err));
		return (err);
	}
	period_size = size;

	// Write the parameters to device
	err = snd_pcm_hw_params(handle, params);
	if (err < 0)
	{
		printf("Unable to set hw params for playback: %s\n", snd_strerror(err));
		return (err);
	}

	return (0);
}

static int set_swparams(snd_pcm_t *handle, snd_pcm_sw_params_t *swparams)
{
	int err;

	// Get the current swparams
	err = snd_pcm_sw_params_current(handle, swparams);
	if (err < 0)
	{
		printf("Unable to determine current swparams for playback: %s\n",
				snd_strerror(err));
		return (err);
	}

	// Start the transfer when the buffer is almost full:
	// (buffer_size / avail_min) * avail_min
	err = snd_pcm_sw_params_set_start_threshold(handle, swparams,
			(buffer_size / period_size) * period_size);
	if (err < 0)
	{
		printf("Unable to set start threshold mode for playback: %s\n",
				snd_strerror(err));
		return (err);
	}

	// Allow the transfer when at least period_size samples can be processed */
	// or disable this mechanism when period event is enabled (aka interrupt like style processing) */
	err = snd_pcm_sw_params_set_avail_min(handle, swparams,
			period_event ? buffer_size : period_size);
	if (err < 0)
	{
		printf("Unable to set avail min for playback: %s\n", snd_strerror(err));
		return (err);
	}

	// Enable period events when requested
	if (period_event)
	{
		err = snd_pcm_sw_params_set_period_event(handle, swparams, 1);
		if (err < 0)
		{
			printf("Unable to set period event: %s\n", snd_strerror(err));
			return (err);
		}
	}

	// Write the parameters to the playback device
	err = snd_pcm_sw_params(handle, swparams);
	if (err < 0)
	{
		printf("Unable to set sw params for playback: %s\n", snd_strerror(err));
		return (err);
	}

	return (0);
}

// Underrun and suspend recovery
static int xrun_recovery(snd_pcm_t *handle, int err)
{
	if (verbose)
		printf("stream recovery\n");

	if (err == -EPIPE)
	{
		// under-run
		err = snd_pcm_prepare(handle);
		if (err < 0)
			printf("Can't recovery from underrun, prepare failed: %s\n",
					snd_strerror(err));
		return (0);
	}
	else if (err == -ESTRPIPE)
	{
		while ((err = snd_pcm_resume(handle)) == -EAGAIN)
			sleep(1); // wait until the suspend flag is released

		if (err < 0)
		{
			err = snd_pcm_prepare(handle);
			if (err < 0)
			{
				printf("Can't recovery from suspend, prepare failed: %s\n",
						snd_strerror(err));
			}
		}
		return (0);
	}

	return (err);
}

// Transfer method - write only
static int write_loop(snd_pcm_t *handle,
					  signed short *samples,
					  snd_pcm_channel_area_t *areas)
{
	double phase = 0;
	signed short *ptr;
	int err, cptr;

	while (true)
	{
		generate_sine(areas, 0, period_size, &phase);
		ptr = samples;
		cptr = period_size;
		while (cptr > 0)
		{
			err = snd_pcm_writei(handle, ptr, cptr);
			if (err == -EAGAIN)
				continue;
			if (err < 0)
			{
				if (xrun_recovery(handle, err) < 0)
				{
					printf("Write error: %s\n", snd_strerror(err));
					exit(EXIT_FAILURE);
				}
				break; // skip one period
			}
			ptr += err * channels;
			cptr -= err;
		}
	}

	return (true);
}

// Transfer method - write and wait for room in buffer using poll
static int wait_for_poll(snd_pcm_t *handle,
						 struct pollfd *ufds,
						 unsigned int count)
{
	unsigned short revents;
	while (true)
	{
		poll(ufds, count, -1);
		snd_pcm_poll_descriptors_revents(handle, ufds, count, &revents);
		if (revents & POLLERR)
			return -EIO;
		if (revents & POLLOUT)
			return (0);
	}

	return (true);
}

// Write and poll loop
static int write_and_poll_loop(snd_pcm_t *handle,
							   signed short *samples,
							   snd_pcm_channel_area_t *areas)
{
	struct pollfd *ufds;
	double phase = 0;
	signed short *ptr;
	int err, count, cptr, init;

	count = snd_pcm_poll_descriptors_count(handle);
	if (count <= 0)
	{
		printf("Invalid poll descriptors count\n");
		return count;
	}

	ufds = (pollfd*)malloc(sizeof(struct pollfd) * count);
	if (ufds == NULL)
	{
		printf("No enough memory\n");
		return -ENOMEM;
	}

	if ((err = snd_pcm_poll_descriptors(handle, ufds, count)) < 0)
	{
		printf("Unable to obtain poll descriptors for playback: %s\n",
				snd_strerror(err));
		return (err);
	}

	init = 1;
	while (true)
	{
		if (!init)
		{
			err = wait_for_poll(handle, ufds, count);
			if (err < 0)
			{
				if (snd_pcm_state(handle) == SND_PCM_STATE_XRUN ||
					snd_pcm_state(handle) == SND_PCM_STATE_SUSPENDED)
				{
					err = snd_pcm_state(handle) == SND_PCM_STATE_XRUN ?
												   -EPIPE : -ESTRPIPE;
					if (xrun_recovery(handle, err) < 0)
					{
						printf("Write error: %s\n", snd_strerror(err));
						exit(EXIT_FAILURE);
					}
					init = 1;
				}
				else
				{
					printf("Wait for poll failed\n");
					return (err);
				}
			}
		}

		generate_sine(areas, 0, period_size, &phase);
		ptr = samples;
		cptr = period_size;
		while (cptr > 0)
		{
			err = snd_pcm_writei(handle, ptr, cptr);
			if (err < 0)
			{
				if (xrun_recovery(handle, err) < 0)
				{
					printf("Write error: %s\n", snd_strerror(err));
					exit(EXIT_FAILURE);
				}
				init = 1;
				break; // skip one period
			}

			if (snd_pcm_state(handle) == SND_PCM_STATE_RUNNING)
				init = 0;
			ptr += err * channels;
			cptr -= err;
			if (cptr == 0)
				break;

			// It is possible, that the initial buffer cannot store
			// all data from the last period, so wait a while
			err = wait_for_poll(handle, ufds, count);
			if (err < 0)
			{
				if (snd_pcm_state(handle) == SND_PCM_STATE_XRUN ||
					snd_pcm_state(handle) == SND_PCM_STATE_SUSPENDED)
				{
					err = snd_pcm_state(handle) == SND_PCM_STATE_XRUN ?
												   -EPIPE : -ESTRPIPE;
					if (xrun_recovery(handle, err) < 0)
					{
						printf("Write error: %s\n", snd_strerror(err));
						exit(EXIT_FAILURE);
					}
					init = 1;
				}
				else
				{
					printf("Wait for poll failed\n");
					return (err);
				}
			}
		}
	}

	return (true);
}

// Transfer method - asynchronous notification
struct async_private_data {signed short *samples;
						   snd_pcm_channel_area_t *areas;
						   double phase;};

static void async_callback(snd_async_handler_t *ahandler)
{
	snd_pcm_t *handle = snd_async_handler_get_pcm(ahandler);
	struct async_private_data *data = (async_private_data *)snd_async_handler_get_callback_private(ahandler);
	signed short *samples = data->samples;
	snd_pcm_channel_area_t *areas = data->areas;
	snd_pcm_sframes_t avail;
	int err;

	avail = snd_pcm_avail_update(handle);
	while (avail >= period_size)
	{
		generate_sine(areas, 0, period_size, &data->phase);
		err = snd_pcm_writei(handle, samples, period_size);
		if (err < 0)
		{
			printf("Write error: %s\n", snd_strerror(err));
			exit(EXIT_FAILURE);
		}

		if (err != period_size)
		{
			printf("Write error: written %i expected %li\n", err, period_size);
			exit(EXIT_FAILURE);
		}
		avail = snd_pcm_avail_update(handle);
	}
}

static int async_loop(snd_pcm_t *handle,
					  signed short *samples,
					  snd_pcm_channel_area_t *areas)
{
	struct async_private_data data;
	snd_async_handler_t *ahandler;
	int err, count;
	data.samples = samples;
	data.areas = areas;
	data.phase = 0;
	err = snd_async_add_pcm_handler(&ahandler, handle, async_callback, &data);
	if (err < 0)
	{
		printf("Unable to register async handler\n");
		exit(EXIT_FAILURE);
	}

	for (count = 0; count < 2; count++)
	{
		generate_sine(areas, 0, period_size, &data.phase);
		err = snd_pcm_writei(handle, samples, period_size);
		if (err < 0)
		{
			printf("Initial write error: %s\n", snd_strerror(err));
			exit(EXIT_FAILURE);
		}

		if (err != period_size)
		{
			printf("Initial write error: written %i expected %li\n", err,
					period_size);
			exit(EXIT_FAILURE);
		}
	}

	if (snd_pcm_state(handle) == SND_PCM_STATE_PREPARED)
	{
		err = snd_pcm_start(handle);
		if (err < 0)
		{
			printf("Start error: %s\n", snd_strerror(err));
			exit(EXIT_FAILURE);
		}
	}

	// because all other work is done in the signal handler,
	// suspend the process
	while (true)
	{
		sleep(1);
	}

	return (true);
}


// Transfer method - asynchronous notification + direct write
static void async_direct_callback(snd_async_handler_t *ahandler)
{
	snd_pcm_t *handle = snd_async_handler_get_pcm(ahandler);
	async_private_data *data = (async_private_data *)snd_async_handler_get_callback_private(ahandler);
	const snd_pcm_channel_area_t *my_areas;
	snd_pcm_uframes_t offset, frames, size;
	snd_pcm_sframes_t avail, commitres;
	snd_pcm_state_t state;
	int first = 0, err;

	while (true)
	{
		state = snd_pcm_state(handle);
		if (state == SND_PCM_STATE_XRUN)
		{
			err = xrun_recovery(handle, -EPIPE);
			if (err < 0)
			{
				printf("XRUN recovery failed: %s\n", snd_strerror(err));
				exit(EXIT_FAILURE);
			}
			first = 1;
		}
		else if (state == SND_PCM_STATE_SUSPENDED)
		{
			err = xrun_recovery(handle, -ESTRPIPE);
			if (err < 0)
			{
				printf("SUSPEND recovery failed: %s\n", snd_strerror(err));
				exit(EXIT_FAILURE);
			}
		}

		avail = snd_pcm_avail_update(handle);
		if (avail < 0)
		{
			err = xrun_recovery(handle, avail);
			if (err < 0)
			{
				printf("avail update failed: %s\n", snd_strerror(err));
				exit(EXIT_FAILURE);
			}
			first = 1;
			continue;
		}

		if (avail < period_size)
		{
			if (first)
			{
				first = 0;
				err = snd_pcm_start(handle);
				if (err < 0)
				{
					printf("Start error: %s\n", snd_strerror(err));
					exit(EXIT_FAILURE);
				}
			}
			else
			{
				break;
			}
			continue;
		}

		size = period_size;
		while (size > 0)
		{
			frames = size;
			err = snd_pcm_mmap_begin(handle, &my_areas, &offset, &frames);
			if (err < 0)
			{
				if ((err = xrun_recovery(handle, err)) < 0)
				{
					printf("MMAP begin avail error: %s\n", snd_strerror(err));
					exit(EXIT_FAILURE);
				}
				first = 1;
			}

			generate_sine(my_areas, offset, frames, &data->phase);
			commitres = snd_pcm_mmap_commit(handle, offset, frames);
			if (commitres < 0 || (snd_pcm_uframes_t) commitres != frames)
			{
				if ((err = xrun_recovery(handle, commitres >= 0 ? -EPIPE : commitres)) < 0)
				{
					printf("MMAP commit error: %s\n", snd_strerror(err));
					exit(EXIT_FAILURE);
				}
				first = 1;
			}
			size -= frames;
		}
	}
}

static int async_direct_loop(snd_pcm_t *handle,
							 signed short *samples ATTRIBUTE_UNUSED,
							 snd_pcm_channel_area_t *areas ATTRIBUTE_UNUSED)
{
	struct async_private_data data;
	snd_async_handler_t *ahandler;
	const snd_pcm_channel_area_t *my_areas;
	snd_pcm_uframes_t offset, frames, size;
	snd_pcm_sframes_t commitres;
	int err, count;
	data.samples = NULL; // We do not require the global sample area for direct write
	data.areas = NULL; // We do not require the global areas for direct write
	data.phase = 0;

	err = snd_async_add_pcm_handler(&ahandler, handle, async_direct_callback, &data);
	if (err < 0)
	{
		printf("Unable to register async handler\n");
		exit(EXIT_FAILURE);
	}

	for (count = 0; count < 2; count++)
	{
		size = period_size;
		while (size > 0)
		{
			frames = size;
			err = snd_pcm_mmap_begin(handle, &my_areas, &offset, &frames);
			if (err < 0)
			{
				if ((err = xrun_recovery(handle, err)) < 0)
				{
					printf("MMAP begin avail error: %s\n", snd_strerror(err));
					exit(EXIT_FAILURE);
				}
			}

			generate_sine(my_areas, offset, frames, &data.phase);
			commitres = snd_pcm_mmap_commit(handle, offset, frames);
			if (commitres < 0 || (snd_pcm_uframes_t) commitres != frames)
			{
				if ((err = xrun_recovery(handle, commitres >= 0 ? -EPIPE : commitres)) < 0)
				{
					printf("MMAP commit error: %s\n", snd_strerror(err));
					exit(EXIT_FAILURE);
				}
			}
			size -= frames;
		}
	}

	err = snd_pcm_start(handle);
	if (err < 0)
	{
		printf("Start error: %s\n", snd_strerror(err));
		exit(EXIT_FAILURE);
	}

	// Because all other work is done in the signal handler,
	// suspend the process
	while (true)
	{
		sleep(1);
	}

	return (true);
}

// Transfer method - direct write only
static int direct_loop(snd_pcm_t *handle,
					   signed short *samples ATTRIBUTE_UNUSED,
					   snd_pcm_channel_area_t *areas ATTRIBUTE_UNUSED)
{
	double phase = 0;
	const snd_pcm_channel_area_t *my_areas;
	snd_pcm_uframes_t offset, frames, size;
	snd_pcm_sframes_t avail, commitres;
	snd_pcm_state_t state;
	int err, first = 1;

	while (true)
	{
		state = snd_pcm_state(handle);
		if (state == SND_PCM_STATE_XRUN)
		{
			err = xrun_recovery(handle, -EPIPE);
			if (err < 0)
			{
				printf("XRUN recovery failed: %s\n", snd_strerror(err));
				return (err);
			}
			first = 1;
		}
		else if (state == SND_PCM_STATE_SUSPENDED)
		{
			err = xrun_recovery(handle, -ESTRPIPE);
			if (err < 0)
			{
				printf("SUSPEND recovery failed: %s\n", snd_strerror(err));
				return (err);
			}
		}

		avail = snd_pcm_avail_update(handle);
		if (avail < 0)
		{
			err = xrun_recovery(handle, avail);
			if (err < 0)
			{
				printf("avail update failed: %s\n", snd_strerror(err));
				return (err);
			}
			first = 1;
			continue;
		}

		if (avail < period_size)
		{
			if (first)
			{
				first = 0;
				err = snd_pcm_start(handle);
				if (err < 0)
				{
					printf("Start error: %s\n", snd_strerror(err));
					exit(EXIT_FAILURE);
				}
			}
			else
			{
				err = snd_pcm_wait(handle, -1);
				if (err < 0)
				{
					if ((err = xrun_recovery(handle, err)) < 0)
					{
						printf("snd_pcm_wait error: %s\n", snd_strerror(err));
						exit(EXIT_FAILURE);
					}
					first = 1;
				}
			}
			continue;
		}

		size = period_size;
		while (size > 0)
		{
			frames = size;
			err = snd_pcm_mmap_begin(handle, &my_areas, &offset, &frames);
			if (err < 0)
			{
				if ((err = xrun_recovery(handle, err)) < 0)
				{
					printf("MMAP begin avail error: %s\n", snd_strerror(err));
					exit(EXIT_FAILURE);
				}
				first = 1;
			}

			generate_sine(my_areas, offset, frames, &phase);
			commitres = snd_pcm_mmap_commit(handle, offset, frames);
			if (commitres < 0 || (snd_pcm_uframes_t) commitres != frames)
			{
				if ((err = xrun_recovery(handle,
						commitres >= 0 ? -EPIPE : commitres)) < 0)
				{
					printf("MMAP commit error: %s\n", snd_strerror(err));
					exit(EXIT_FAILURE);
				}
				first = 1;
			}
			size -= frames;
		}
	}

	return (true);
}

// Transfer method - direct write only using mmap_write functions
static int direct_write_loop(snd_pcm_t *handle,
							 signed short *samples,
							 snd_pcm_channel_area_t *areas)
{
	double phase = 0;
	signed short *ptr;
	int err, cptr;

	while (true)
	{
		generate_sine(areas, 0, period_size, &phase);
		ptr = samples;
		cptr = period_size;
		while (cptr > 0)
		{
			err = snd_pcm_mmap_writei(handle, ptr, cptr);
			if (err == -EAGAIN)
				continue;
			if (err < 0)
			{
				if (xrun_recovery(handle, err) < 0)
				{
					printf("Write error: %s\n", snd_strerror(err));
					exit(EXIT_FAILURE);
				}
				break; // Skip one period
			}
			ptr += err * channels;
			cptr -= err;
		}
	}

	return (true);
}

struct transfer_method
{
	const char *name;
	snd_pcm_access_t access;
	int (*transfer_loop)(snd_pcm_t *handle,
						 signed short *samples,
						 snd_pcm_channel_area_t *areas);
};

static struct transfer_method transfer_methods[] =
{
	{ "write",					SND_PCM_ACCESS_RW_INTERLEAVED, 		write_loop },
	{ "write_and_poll", 		SND_PCM_ACCESS_RW_INTERLEAVED, 		write_and_poll_loop },
	{ "async", 					SND_PCM_ACCESS_RW_INTERLEAVED, 		async_loop },
	{ "async_direct", 			SND_PCM_ACCESS_MMAP_INTERLEAVED, 	async_direct_loop },
	{ "direct_interleaved", 	SND_PCM_ACCESS_MMAP_INTERLEAVED, 	direct_loop },
	{ "direct_noninterleaved", 	SND_PCM_ACCESS_MMAP_NONINTERLEAVED, direct_loop },
	{ "direct_write", 			SND_PCM_ACCESS_MMAP_INTERLEAVED, 	direct_write_loop },
	{ NULL, 					SND_PCM_ACCESS_RW_INTERLEAVED, 		NULL }
};

static void help(void)
{
	int k;
	printf( "Usage: pcm [OPTION]... [FILE]...\n"
		    "-h,--help help\n"
		    "-D,--device playback device\n"
			"-r,--rate stream rate in Hz\n"
			"-c,--channels count of channels in stream\n"
			"-f,--frequency sine wave frequency in Hz\n"
			"-p,--period period size in us\n"
			"-b,--buffer ring buffer size in us\n"
			"-m,--method transfer method\n"
			"-o,--format sample format\n"
			"-v,--verbose show the PCM setup parameters\n"
			"-n,--noresample do not resample\n"
			"-e,--pevent enable poll event after each period\n"
			"\n");

	printf("Recognized sample formats are:");
	for (k = 0; k < SND_PCM_FORMAT_LAST; ++k)
	{
		snd_pcm_format_t format;
		format = _snd_pcm_format(k);
		const char *s = snd_pcm_format_name(format);
		if (s)
			printf(" %s", s);
	}

	printf("\n");
	printf("Recognized transfer methods are:");
	for (k = 0; transfer_methods[k].name; k++)
		printf(" %s", transfer_methods[k].name);
	printf("\n");
}

int main(int argc, char *argv[])
{
	struct option long_option[] =
	{
		{ "help", 		0, NULL, 'h' },
		{ "device", 	1, NULL, 'D' },
		{ "rate", 		1, NULL, 'r' },
		{ "channels", 	1, NULL, 'c' },
		{ "frequency", 	1, NULL, 'f' },
		{ "buffer", 	1, NULL, 'b' },
		{ "period", 	1, NULL, 'p' },
		{ "method", 	1, NULL, 'm' },
		{ "format", 	1, NULL, 'o' },
		{ "verbose", 	1, NULL, 'v' },
		{ "noresample", 1, NULL, 'n' },
		{ "pevent", 	1, NULL, 'e' },
		{ NULL, 		0, NULL, 0   },
	};

	snd_pcm_t *handle;
	int err, morehelp, formatNum;
	snd_pcm_hw_params_t *hwparams;
	snd_pcm_sw_params_t *swparams;
	int method = 0;
	signed short *samples;
	unsigned int chn;
	snd_pcm_channel_area_t *areas;
	morehelp = 0;

	// Get the HW and SW parameters
	snd_pcm_hw_params_alloca(&hwparams);
	snd_pcm_sw_params_alloca(&swparams);

	while (true)
	{
		char c;
		if ((c = getopt_long(argc, argv, "hD:r:c:f:b:p:m:o:vne", long_option, NULL)) < 0)
			break;

		switch (c)
		{
		case 'h':
			morehelp++;
			break;

		case 'D':
			device = strdup(optarg);
			break;

		case 'r':
			rate = atoi(optarg);
			rate = rate < 4000 ? 4000 : rate;
			rate = rate > 196000 ? 196000 : rate;
			break;

		case 'c':
			channels = atoi(optarg);
			channels = channels < 1 ? 1 : channels;
			channels = channels > 1024 ? 1024 : channels;
			break;

		case 'f':
			freq = atoi(optarg);
			freq = freq < 50 ? 50 : freq;
			freq = freq > 5000 ? 5000 : freq;
			break;

		case 'b':
			buffer_time = atoi(optarg);
			buffer_time = buffer_time < 1000 ? 1000 : buffer_time;
			buffer_time = buffer_time > 1000000 ? 1000000 : buffer_time;
			break;

		case 'p':
			period_time = atoi(optarg);
			period_time = period_time < 1000 ? 1000 : period_time;
			period_time = period_time > 1000000 ? 1000000 : period_time;
			break;

		case 'm':
			for (method = 0; transfer_methods[method].name; method++)
				if (!strcasecmp(transfer_methods[method].name, optarg))
					break;
			if (transfer_methods[method].name == NULL)
				method = 0;
			break;

		case 'o':
			for (formatNum = 0; formatNum < (int)SND_PCM_FORMAT_LAST; formatNum++)
			{
				snd_pcm_format_t format;
				format = (snd_pcm_format_t)formatNum;
				const char *format_name = snd_pcm_format_name(format);
				if (format_name)
					if (!strcasecmp(format_name, optarg))
						break;
			}

			if (format == SND_PCM_FORMAT_LAST)
				format = SND_PCM_FORMAT_S16;
			if (!snd_pcm_format_linear(format) &&
				!(format == SND_PCM_FORMAT_FLOAT_LE ||
				  format == SND_PCM_FORMAT_FLOAT_BE))
			{
				printf("Invalid (non-linear/float) format %s\n", optarg);
				return (1);
			}
			break;

		case 'v':
			verbose = 1;
			break;

		case 'n':
			resample = 0;
			break;

		case 'e':
			period_event = 1;
			break;
		}
	}

	if (morehelp)
	{
		help();
		return (0);
	}

	err = snd_output_stdio_attach(&output, stdout, 0);
	if (err < 0)
	{
		printf("Output failed: %s\n", snd_strerror(err));
		return (0);
	}

	printf("Playback device is %s\n", device);
	printf("Stream parameters are %iHz, %s, %i channels\n", rate,
			snd_pcm_format_name(format), channels);
	printf("Sine wave rate is %.4fHz\n", freq);
	printf("Using transfer method: %s\n", transfer_methods[method].name);

	if ((err = snd_pcm_open(&handle, device, SND_PCM_STREAM_PLAYBACK, 0)) < 0)
	{
		printf("Playback open error: %s\n", snd_strerror(err));
		return (0);
	}

	if ((err = set_hwparams(handle, hwparams, transfer_methods[method].access)) < 0)
	{
		printf("Setting of hwparams failed: %s\n", snd_strerror(err));
		exit(EXIT_FAILURE);
	}

	if ((err = set_swparams(handle, swparams)) < 0)
	{
		printf("Setting of swparams failed: %s\n", snd_strerror(err));
		exit(EXIT_FAILURE);
	}

	if (verbose > 0)
		snd_pcm_dump(handle, output);

	samples = (short int *)malloc((period_size * channels * snd_pcm_format_physical_width(format)) / 8);
	if (samples == NULL)
	{
		printf("No enough memory\n");
		exit(EXIT_FAILURE);
	}

	areas = (snd_pcm_channel_area_t *)calloc(channels, sizeof(snd_pcm_channel_area_t));
	if (areas == NULL)
	{
		printf("No enough memory\n");
		exit(EXIT_FAILURE);
	}

	for (chn = 0; chn < channels; chn++)
	{
		areas[chn].addr = samples;
		areas[chn].first = chn * snd_pcm_format_physical_width(format);
		areas[chn].step = channels * snd_pcm_format_physical_width(format);
	}

	// Execute transfer method
	err = transfer_methods[method].transfer_loop(handle, samples, areas);
	if (err < 0)
		printf("Transfer failed: %s\n", snd_strerror(err));

	// Free memory
	free(areas);
	free(samples);
	snd_pcm_close(handle);

	return (0);
}
